home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 9 / FM Towns Free Software Collection 9.iso / t_os / tool / gara2 / spp / src / sppm.c < prev   
Encoding:
C/C++ Source or Header  |  1994-11-16  |  36.8 KB  |  1,815 lines
  1. /* スプライトプロセッサ用ルーチン */
  2.  
  3.  
  4. /* ＰＡＴファイルのヘッダ */
  5. typedef struct
  6. {
  7.     int        a;                /* 意味無し */
  8.     char    name[41];        /* 名前 */
  9.     char    subname[15];
  10.     int        xlen,ylen,bufx,bufy,patbufsize,res1;
  11.     char    selected,nodisp;
  12.     int        res2,res3;
  13.     char    res4[34];
  14. } P_HEAD;
  15.  
  16.  
  17. typedef struct
  18. {
  19.     short    patnum;        /* キャラクタの数 */
  20.     short    palnum;        /* パレットの数 */
  21.     short    sprnum;        /* スプライトパターンの数 */
  22. } S_HEAD;
  23.  
  24.  
  25. typedef struct
  26. {
  27.     short    topnum;        /* 先頭パターン番号 */
  28.     short    xlen;        /* 横方向パターン数 */
  29.     short    ylen;        /* 縦方向パターン数 */
  30.     short     col;        /* 色テーブル番号として設定する値 */
  31. } CHRDAT;
  32.  
  33.  
  34. /* パターンデータ格納用構造体 */
  35. typedef struct
  36. {
  37.     char    *header;        /* ARTemis用のヘッダ */
  38.     int        patx,paty;        /* １６ドット単位でのサイズ */
  39.     char    *patbuf;        /* パターン格納領域(16) */
  40.     short    *p32buf;        /* パターン格納領域(32K) */
  41.     int        palnum;            /* 参照するパレットの番号(-1で32K色) */
  42. } PATTERN;
  43.  
  44.  
  45.  
  46.  
  47. /* グローバル変数 */
  48. char    path[64]="";        /* 現在のパス */
  49. unsigned int drv=0;            /* 現在のドライブ */
  50. char    workfn[100];        /* 作業中ファイルのフルパス */
  51. PATTERN    pter[1024];            /* パターンデータ格納用 */
  52. int        PALNUM=0,PATNUM=0;    /* メモリ上に有るパレット,パターンの総数 */
  53. int        SPRNUM=0;            /* メモリ上に有るスプライトの総数 */
  54. short    PAL_USE[1024];        /* そのパレットが幾つのパターンに使用されてるか */
  55. short    PAL[1024][16];        /* パレットデータ */
  56. short    stkpal=-1;            /* スタック内のパレットデータ */
  57.  
  58. char    *fileSelBuf;        /* ファイルセレクタ描画用バッファ */
  59. char    *zoomDlgBuf;        /* 拡大ビュアー描画用バッファ */
  60. short    *magBuf;            /* 拡大後のパターン保持用バッファ */
  61. char    saveBuf[512];        /* セーバー用ワーク */
  62. char    *sureBuf;            /* SPM_sureのダイアログ描画用バッファ */
  63. char    *errMesBuf;            /* SPM_errMesの描画用バッファ */
  64. char    *frameBuf;            /* 再描画用のバッファ */
  65.  
  66. /* Ａｂｏｕｔ．．． */
  67. void    SPM_about()
  68. {
  69.     int        x,y,b,xd,yd;
  70.     char    *buf;
  71.     if ( (buf=YGU_pushScreenBlock(gwork,156,190,200,100))==NULL)
  72.         return;
  73.     /* 気合を込めて！(^^;) */
  74.     MOS_disp(0);
  75.     MOS_rdpos(&b,&x,&y);
  76.     MOS_horizon(156,355);
  77.     MOS_vertical(190,289);
  78.     YGB_writeMode(gwork,PSET);
  79.     SGB_gradProButton(gwork,156,190,355,289,_C(27,27,18),_C(9,9,6),0);
  80.     YGB_fontSize(gwork,8,16);
  81.     YGB_color(gwork,_C(9,4,0));
  82.     YGB_print(gwork,192,220,"SPrite Processor");
  83.     YGB_print(gwork,193,220,"SPrite Processor");
  84.     YGB_color(gwork,_C(11,5,2));
  85.     YGB_fontSize(gwork,8,12);
  86.     YGB_print(gwork,224,240,"Ver1.00");
  87.     YGB_print(gwork,225,240,"Ver1.00");
  88.     
  89.     YGB_color(gwork,_C(0,0,0));
  90.     YGB_fontSize(gwork,6,12);
  91.     YGB_print(gwork,208,276,"MXMIV (C)SANDMAN");
  92.     YGB_print(gwork,263,276,"SANDMAN");
  93.     b=0;
  94.     MOS_setpos(256,240);
  95.     MOS_disp(1);
  96.     while (b==0)
  97.         MOS_rdpos(&b,&xd,&yd);
  98.     YGU_popScreenBlock(gwork,buf);
  99.     MOS_horizon(0,505);
  100.     MOS_vertical(0,473);
  101.     MOS_setpos(x,y);
  102.     return;
  103. }
  104.  
  105.  
  106. /* エラーメッセージの表示 */
  107. void    SPM_errMes(char *str)
  108. {
  109.     int        x,y,dmy,b=0,lx;
  110.     char    *buf;
  111.     unsigned int len;
  112.     
  113.     len=strlen(str);
  114.     lx=len*6+4;
  115.     
  116.     if (len>80)
  117.     {    SPM_errMes("阿呆！ > 自分"); return; }
  118.     
  119.     MOS_rdpos(&b,&x,&y);
  120.     MOS_disp(0);
  121.     YGB_getPattern(gwork,errMesBuf,x-lx/2,y-8,x+lx/2,y+7);
  122.     YGB_writeMode(gwork,PSET);
  123.     SGB_gradStrProButton(gwork,x-lx/2,y-8,_C(18,25,18),_C(8,8,8),0,str,
  124.     6,12,0,_C(31,31,31));
  125.     MOS_disp(1);
  126.     while (b==0)
  127.         MOS_rdpos(&b,&dmy,&dmy);
  128.     MOS_disp(0);
  129.     YGB_putPattern(gwork,errMesBuf,x-lx/2,y-8,x+lx/2,y+7);
  130.     MOS_disp(1);
  131.     return;
  132. }
  133.  
  134.  
  135.  
  136.  
  137. /* YES? NO? ...def=0 で YES/NO, def=2で確認 , def=9999 でパレット*/
  138. int        SPM_sure(char *mes,int def)
  139. {
  140.     int        x0,y0;
  141.     int        a,x,y,len,sx,sy,val;
  142.     ITEM    *itms[2],*act;
  143.     char    *pushBuf,*tok,*sp;
  144.     char    str[500];
  145.     
  146.     sp=str;
  147.     
  148.     strcpy(str,mes);
  149.     
  150.     MOS_disp(0);
  151.     YGB_writeMode(gwork,PSET);
  152.     MOS_rdpos(&a,&x,&y);
  153.     x0=x-124;
  154.     x0= (x0<0)     ? 0   : x0;
  155.     x0= (x0>264) ? 264 : x0;
  156.     y0=y-60;
  157.     y0= (y0<0)     ? 0   : y0;
  158.     y0= (y0>359) ? 359 : y0;
  159.     
  160.     MOS_disp(0);
  161.     YGB_getPattern(gwork,sureBuf,x0,y0,x0+247,y0+120);
  162.     
  163.     /* ダイアログベース */
  164.     SGB_proButton(gwork,x0,y0,x0+247,y0+120, _C(4,4,4));
  165.     
  166.     /* タイトルバー */
  167.     SGB_gradProButton(gwork,x0,y0,x0+247,y0+60,_C(27,27,18),_C(9,9,6),0);
  168.     /* 表示領域 */
  169.     SGB_holButton(gwork,x0+12,y0+12,x0+235,y0+79, _C(3,3,3));
  170.     
  171.     /* 文字列の描画 */
  172.     YGB_fontSize(gwork,6,12);
  173.     YGB_color(gwork,_C(24,24,27));
  174.     sy=y0+28;
  175.     sp=strtok(sp,"@@");
  176.     len=strlen(sp);    sx=x0+124-len*3;
  177.     YGB_print(gwork,sx,sy,sp);
  178.     
  179.     while(1)
  180.     {
  181.         sy+=12;
  182.         sp=strtok(NULL,"@@");
  183.         if (sp==NULL)
  184.             break;
  185.         len=strlen(sp);    sx=x0+124-len*3;
  186.         YGB_print(gwork,sx,sy,sp);
  187.     }
  188.     
  189.     /* パレットバッファの内容表示 */
  190.     if (def==9999 && stkpal!=-1)
  191.     {
  192.         YGB_writeMode(gwork,OPAQUE);
  193.         YGB_color(gwork,_C(24,24,24));
  194.         YGB_boxFul(gwork,x0+59,y0+71,x0+187,y0+78);
  195.         for (x=0;x<16;x++)
  196.         {
  197.             YGB_color(gwork,PAL[stkpal][x]);
  198.             YGB_boxFul(gwork,x0+60+x*8,y0+72,x0+66+x*8,y0+78);
  199.         }
  200.         YGB_writeMode(gwork,PSET);
  201.         def=0;
  202.     }
  203.     
  204.     
  205.     if (def!=2)
  206.     {
  207.         /* YES */
  208.         SGB_proButton(gwork,x0+32,y0+91,x0+86,y0+110, _C(6,6,6));
  209.         YGB_color(gwork,_C(23,23,23));
  210.         YGB_fontSize(gwork,8,16);
  211.         YGB_print(gwork,x0+47,y0+109,"YES");
  212.         YGB_print(gwork,x0+48,y0+109,"YES");
  213.         itms[0]=YGU_addButton(NULL,x0+32,y0+91,55,20);
  214.         /* NO */
  215.         SGB_proButton(gwork,x0+164,y0+91,x0+218,y0+110, _C(6,6,6));
  216.         YGB_color(gwork,_C(20,20,20));
  217.         YGB_fontSize(gwork,8,16);
  218.         YGB_print(gwork,x0+183,y0+109,"NO");
  219.         YGB_print(gwork,x0+184,y0+109,"NO");
  220.         itms[1]=YGU_addButton(itms[0],x0+164,y0+91,55,20);
  221.     }
  222.     else
  223.     {
  224.         /* OK */
  225.         SGB_proButton(gwork,x0+98,y0+91,x0+152,y0+110, _C(6,6,6));
  226.         YGB_color(gwork,_C(23,23,23));
  227.         YGB_fontSize(gwork,8,16);
  228.         YGB_print(gwork,x0+119,y0+109,"OK");
  229.         YGB_print(gwork,x0+120,y0+109,"OK");
  230.         itms[0]=YGU_addButton(NULL,x0+98,y0+91,55,20);
  231.         /* ダミー(クリック出来ない) */
  232.         itms[1]=YGU_addButton(itms[0],511,479,1,1);
  233.     }
  234.     
  235.     MOS_disp(1);
  236.     while(1)
  237.     {
  238.         act=YGU_allItemsAction(gwork,itms[0]);
  239.         if (act==itms[0])
  240.         {    val=1;    break; }
  241.         if (act==itms[1])
  242.         {    val=0;    break; }
  243.         MOS_rdpos(&a,&x,&y);
  244.         if (a==2)
  245.         {    val=def; break; }
  246.     }
  247.     
  248.     MOS_disp(0);
  249.     YGB_putPattern(gwork,sureBuf,x0,y0,x0+247,y0+120);
  250.     MOS_disp(1);
  251.     YGU_deleteAll(itms[0]);
  252.     return(val);
  253. }
  254.  
  255.  
  256.  
  257.  
  258. /* 現在の左上パターン番号とかを表示する */
  259. void    SPM_printNumber(num)
  260. {
  261.     char    str[40];
  262.     int        ppal=0,i;
  263.     
  264.     SPRNUM=0;
  265.     if (PAL_USE[stkpal]==1)
  266.         ppal=1;
  267.     for (i=0;i<PATNUM;i++)
  268.         SPRNUM+=((pter[i].patx*pter[i].paty)*((pter[i].palnum==-1) ? 4 : 1));
  269.     
  270.     YGB_fontSize(gwork,6,12);
  271.     YGB_color(gwork,_C(27,27,27));
  272.     YGB_writeMode(gwork,OPAQUE);
  273.     sprintf(str,"%04d/%04d SPR:%04d PAL:%04d",num,PATNUM,SPRNUM,PALNUM-ppal);
  274.     YGB_print(gwork,print_x+26,print_y+13,str);
  275.     return;
  276. }
  277.  
  278.  
  279.  
  280.  
  281. /* ものぐさファイルセレクト関数 */
  282. void    SPM_fileSelect(char *msg,char *fn,char *wild)
  283. {
  284.     int        x,y,b,ret;
  285.     char    *buf;
  286.     
  287.     MOS_rdpos(&b,&x,&y);
  288.     x = (x<60) ? 0 : x-60;
  289.     y = (y<144) ? 20 : y-124;
  290.     
  291.     MOS_disp(0);
  292.     YGB_getPattern(gwork,fileSelBuf,x,y,x+119,y+247);
  293.     MOS_disp(1);
  294.     
  295.     ret=YGU_fileSelect(gwork,msg,&drv,path,fn,wild,x,y,120,248,6,12);
  296.     
  297.     if (ret==0)
  298.         fn[0]=0;
  299.     MOS_disp(0);
  300.     YGB_putPattern(gwork,fileSelBuf,x,y,x+119,y+247);
  301.     MOS_disp(1);
  302.     YGB_writeMode(gwork,PSET);
  303.     return;
  304. }
  305.  
  306.  
  307. /* 最適化済１６色データを３２Ｋ色モードに戻す */
  308. void    SPM_expand(int ref,int lx,int ly,short *pal,short *tmpbuf)
  309. {
  310.     int        xlen,ylen,loop_x,loop_y,i,j;
  311.     short    upper,lower;
  312.     
  313.     /* calloc な感じにする */
  314.     _fill_char(tmpbuf,lx*ly*2,0);
  315.     
  316.     ylen=pter[ref].paty << 4;
  317.     xlen=pter[ref].patx << 4;
  318.     loop_y=(ylen<ly) ? ylen : ly;
  319.     loop_x=(xlen<lx) ? xlen : lx;
  320.     
  321.     if (pter[ref].palnum!=-1)
  322.     {
  323.         for (i=0;i<loop_y;i++)
  324.         {
  325.             for (j=0;j<loop_x/2;j++)
  326.             {
  327.                 /* １６ビットデータに直す */
  328.                 /* 上下４ビットに分ける　*/
  329.                 upper=pter[ref].patbuf[(i*xlen>>1)+j];
  330.                 lower=upper & 15;    upper=upper >> 4;
  331.                 upper=PAL[pter[ref].palnum][upper];
  332.                 lower=PAL[pter[ref].palnum][lower];
  333.                 tmpbuf[i*lx+(j<<1)]=  upper;
  334.                 tmpbuf[i*lx+(j<<1)+1]=lower;
  335.             }
  336.         }
  337.     }
  338.     else
  339.     {
  340.         for (i=0;i<loop_y;i++)
  341.             _move(&pter[ref].p32buf[i*xlen],&tmpbuf[i*lx],loop_x*2);
  342.     }
  343.     return;
  344. }
  345.  
  346.  
  347.  
  348. /* 加工中のパターンデータを表示枠に転送 */
  349. void    SPM_showWindow(int patnum)
  350. {
  351.     int        x,y,sx,sy,i,j;
  352.     int        xlen,ylen,loop_x,loop_y;
  353.     short    upper,lower;
  354.     short    *tmpbuf;
  355.     int        ref;
  356.     
  357.     MOS_disp(0);
  358.     
  359.     if ((tmpbuf=malloc(8192))==NULL)
  360.     {    SPM_errMes("メモリが足りません");    return;    }
  361.     
  362.     YGB_writeMode(gwork,OPAQUE);
  363.     
  364.     for (y=0;y<4;y++)
  365.     {
  366.         for (x=0;x<6;x++)
  367.         {
  368.             /* 座標を定める */
  369.             sx= x * sprWinStep_x + sprWin_x + 6;
  370.             sy= y * sprWinStep_y + sprWin_y + 6;
  371.             
  372.             /* 要求されたパターン番号が大きいときはHolButton */
  373.             if (PATNUM <= y*6+x+patnum)
  374.             {
  375.                 SGB_holButton(gwork,sx,sy,sx+63,sy+63, _C(0,0,0));
  376.                 YGB_color(gwork,0);
  377.                 YGB_boxFul(gwork,sx-4,sy+74,sx+66,sy+90);
  378.                 continue;
  379.             }
  380.             
  381.             /* そうでないならパターンを枠内に転送 */
  382.             ref=y*6+x+patnum;
  383.             SPM_expand(ref,64,64,PAL[pter[ref].palnum],tmpbuf);
  384.             YGB_putPattern(gwork,(char*)tmpbuf,sx,sy,sx+63,sy+63);
  385.             
  386.             /* 次にパレット */
  387.             if (pter[ref].palnum!=-1)
  388.             {
  389.                 YGB_color(gwork,0);
  390.                 YGB_boxFul(gwork,sx-4,sy+74,sx+66,sy+90);
  391.                 for (i=0;i<2;i++)
  392.                 {
  393.                     for (j=0;j<8;j++)
  394.                     {
  395.                         YGB_color(gwork,PAL[pter[ref].palnum][(i<<3) +j]);
  396.                         YGB_boxFul(gwork,sx-4+j*9,sy+74+i*9,
  397.                                     sx+3+j*9,sy+81+i*9);
  398.                     }
  399.                 }
  400.             }
  401.             else
  402.             {
  403.                 YGB_color(gwork,0);
  404.                 YGB_boxFul(gwork,sx-4,sy+74,sx+66,sy+90);
  405.                 YGB_color(gwork,_C(24,24,24));
  406.                 YGB_fontSize(gwork,6,12);
  407.                 YGB_print(gwork,sx,sy+88,"32K data");
  408.             }
  409.         }
  410.     }
  411.     MOS_disp(1);
  412.     YGB_writeMode(gwork,PSET);
  413.     free(tmpbuf);
  414.     return;
  415. }
  416.  
  417.  
  418.  
  419.  
  420. void    SPM_showOne(int ref)
  421. {
  422.     int        x,y,sx,sy,i,j;
  423.     int        xlen,ylen;
  424.     short    *tmpbuf;
  425.     
  426.     if ( (ref<WINTOP*6) || ((ref-WINTOP*6)>=24) )
  427.         return;
  428.     
  429.     MOS_disp(0);
  430.     
  431.     
  432.     YGB_writeMode(gwork,OPAQUE);
  433.     
  434.     y=(ref-WINTOP*6)/6;
  435.     x=(ref-WINTOP*6)%6;
  436.     
  437.     /* 座標を定める */
  438.     sx= x * sprWinStep_x + sprWin_x + 6;
  439.     sy= y * sprWinStep_y + sprWin_y + 6;
  440.     
  441.     /* 要求されたパターン番号が大きいときはHolButton */
  442.     if (PATNUM <= ref)
  443.     {
  444.         SGB_holButton(gwork,sx,sy,sx+63,sy+63, _C(0,0,0));
  445.         YGB_color(gwork,0);
  446.         YGB_boxFul(gwork,sx-4,sy+74,sx+66,sy+90);
  447.         MOS_disp(1);
  448.         YGB_writeMode(gwork,PSET);
  449.         return;
  450.     }
  451.     
  452.     /* そうでないならパターンを枠内に転送 */
  453.     if ((tmpbuf=malloc(8192))==NULL)
  454.     {    SPM_errMes("メモリが足りません");    return;    }
  455.     SPM_expand(ref,64,64,PAL[pter[ref].palnum],tmpbuf);
  456.     YGB_putPattern(gwork,(char*)tmpbuf,sx,sy,sx+63,sy+63);
  457.     
  458.     /* 次にパレット */
  459.     if (pter[ref].palnum!=-1)
  460.     {
  461.         YGB_color(gwork,0);
  462.         YGB_boxFul(gwork,sx-4,sy+74,sx+66,sy+90);
  463.         for (i=0;i<2;i++)
  464.         {
  465.             for (j=0;j<8;j++)
  466.             {
  467.                 YGB_color(gwork,PAL[pter[ref].palnum][(i<<3) +j]);
  468.                 YGB_boxFul(gwork,sx-4+j*9,sy+74+i*9,
  469.                             sx+3+j*9,sy+81+i*9);
  470.             }
  471.         }
  472.     }
  473.     else
  474.     {
  475.         YGB_color(gwork,0);
  476.         YGB_boxFul(gwork,sx-4,sy+74,sx+66,sy+90);
  477.         YGB_color(gwork,_C(24,24,24));
  478.         YGB_fontSize(gwork,6,12);
  479.         YGB_print(gwork,sx,sy+88,"32K data");
  480.     }
  481.  
  482.     MOS_disp(1);
  483.     YGB_writeMode(gwork,PSET);
  484.     free(tmpbuf);
  485.     return;
  486. }
  487.  
  488.  
  489.  
  490. void    SPM_scrollShowWindow(int diff)
  491. {
  492.     short    *copybuf;
  493.     int        x,y,sx,sy,dx,dy,num,ref;
  494.     int        kaishi,keizoku,jikko;        /* ひどい名前(^^;) */
  495.     int        plus;
  496.     
  497.     WINTOP+=diff;
  498.     
  499.     MOS_disp(0);
  500.     YGB_writeMode(gwork,OPAQUE);
  501.     
  502.     /* まず、コピーから */
  503.     
  504.     kaishi=    (diff<0) ?    diff+3    : diff;
  505.     keizoku=(diff<0) ?  -1        : 4;
  506.     jikko=    (diff<0) ?    -1        : 1;
  507.     
  508.     for (y=kaishi;y!=keizoku;y+=jikko)    
  509.     {
  510.         for (x=0;x<6;x++)
  511.         {
  512.             sx= x * sprWinStep_x + sprWin_x + 6;
  513.             sy= y * sprWinStep_y + sprWin_y + 6;
  514.             dx= sx;
  515.             dy= (y-diff) * sprWinStep_y + sprWin_y + 6;
  516.             
  517.             
  518.             if ((copybuf=malloc(8192))==NULL)
  519.             {    SPM_errMes("メモリが足りません");    return;    }
  520.             YGB_getPattern(gwork,(char*)copybuf,sx,sy,sx+63,sy+63);
  521.             YGB_putPattern(gwork,(char*)copybuf,dx,dy,sx+63,dy+63);
  522.             free(copybuf);
  523.             copybuf=malloc(71*17*2);
  524.             YGB_getPattern(gwork,(char*)copybuf,sx-4,sy+74,sx+66,sy+90);
  525.             YGB_putPattern(gwork,(char*)copybuf,dx-4,dy+74,dx+66,dy+90);
  526.             free(copybuf);
  527.         }
  528.     }
  529.  
  530.  
  531.     num=WINTOP*6;
  532.     /* 次は新しく描く */
  533.     if (diff>0)
  534.     {
  535.         for (y=4-diff;y<=3;y++)
  536.         {
  537.             for    (x=0;x<6;x++)
  538.             {
  539.                 ref=(WINTOP+y)*6+x;
  540.                 SPM_showOne(ref);
  541.             }
  542.         }
  543.     }
  544.     else
  545.     {
  546.         for (y=0;y<_abs(diff);y++)
  547.         {
  548.             for    (x=0;x<6;x++)
  549.             {
  550.                 ref=(WINTOP+y)*6+x;
  551.                 SPM_showOne(ref);
  552.             }
  553.         }
  554.     }
  555.     
  556.     MOS_disp(1);
  557.     return;
  558. }
  559.  
  560.  
  561. /* ファイルメニュー
  562.  
  563.     /* PATファイル新規読み込み */
  564. void    SPM_readNewPAT()
  565. {
  566.     P_HEAD    header;
  567.     char    *pat;                /* 最適化後のパターン格納領域 */
  568.     short    pal[16];            /* パレットデータ格納領域 */
  569.     short    *patbuf;            /* パターンデータ格納用 */
  570.     short    *tmpbuf;            /* ファイルから読んだ直後のパターン */
  571.     char    fn[13];                /* ファイルネーム */
  572.     int        xlen,ylen;            /* パターンのサイズ */
  573.     int        patx,paty;            /* １６ドット単位のパターンの数 */
  574.     int        dotnum;                /* ドットの数 */
  575.     int        i,j,ret,pt=0;
  576.     
  577.     
  578.     fn[0]=0;
  579.     SPM_fileSelect("ARTemisロード",fn,"");
  580.     if (fn[0]==0)
  581.         return;
  582.     
  583.     YSC_makeFullPath(workfn,drv,path,fn);
  584.     
  585.     if ( (fp=fopen(workfn,"rb"))==NULL)
  586.     {    SPM_errMes("ファイルエラー！"); return;    }
  587.     
  588.     /* いままで保持していたデータ領域の開放 */
  589.     for (i=0;i<PATNUM;i++)
  590.     {
  591.         free(pter[i].patbuf);
  592.         free(pter[i].p32buf);
  593.         if (pter[i].header!=NULL)
  594.         free(pter[i].header);
  595.     }
  596.     PATNUM=0;    PALNUM=0;    SPRNUM=0;    stkpal=-1;
  597.     
  598.     fread(&header,sizeof(P_HEAD),1,fp);
  599.     while (!feof(fp))
  600.     {
  601.         /* 読み取り用ポインタ初期化 */
  602.         pt=0;
  603.         /* まずヘッダの解析から */
  604.         /* パターンのサイズを計算 */
  605.         xlen=header.xlen;    ylen=header.ylen;
  606.         patx=(xlen+15)>>4;    paty=(ylen+15)>>4;
  607.         dotnum=patx*paty<<8;
  608.         
  609.         /* パターンデータをメモリに格納 */
  610.         if ( (patbuf=calloc(dotnum*2,1))==NULL)
  611.         { SPM_errMes("メモリが足りません"); return; }
  612.         if ( (tmpbuf=malloc(header.patbufsize))==NULL)
  613.         { SPM_errMes("メモリが足りません"); return; }
  614.         
  615.         fread(tmpbuf,header.patbufsize,1,fp);
  616.         
  617.         /* デバッグ */
  618.         //YGB_putPattern(gwork,(char*)tmpbuf,0,0,239,199);
  619.         
  620.         
  621.         for (i=0;i<ylen;i++)
  622.         {
  623.             for (j=0;j<xlen;j++)
  624.             {    patbuf[(i*patx<<4)+j]=tmpbuf[pt]; pt++;    }
  625.         }
  626.         free(tmpbuf);
  627.         
  628.         /* 構造体の中に入れておく。 */
  629.         pter[PATNUM].patx=patx;
  630.         pter[PATNUM].paty=paty;
  631.         pter[PATNUM].header=malloc(128);
  632.         _move(&header,pter[PATNUM].header,128);
  633.         pter[PATNUM].p32buf=patbuf;
  634.         if ((pter[PATNUM].patbuf=malloc(dotnum/2))==NULL)
  635.         {    SPM_errMes("メモリ不足です"); fclose(fp); return; }
  636.         pter[PATNUM].palnum=-1;
  637.         
  638.         /* デバッグ2 */
  639.         //printf ("No.%03d patx=%02d paty=%02d",PALNUM,patx,paty);
  640.         
  641.         /* 変数をセット */
  642.         PATNUM++;
  643.         SPRNUM+=(patx*paty)*4;
  644.         
  645.         fread(&header,sizeof(P_HEAD),1,fp);
  646.     }
  647.     
  648.     /* スクロールバーを書き換え */
  649.     YGU_resetScrollBar(gwork,itm[29],(PATNUM+5)/6,4);
  650.     WINTOP=0;
  651.     YGB_writeMode(gwork,PSET);
  652.     
  653.     SPM_showWindow(0);
  654.     SPM_printNumber(0);
  655.     
  656.     /* パレットの使用状態フラグをクリア */
  657.     _fill_char(PAL_USE,2048,0);
  658.     
  659.     fclose(fp);
  660.     return;
  661. }
  662.  
  663.  
  664.  
  665.  
  666.     /* PATファイル追加読み込み */
  667. void    SPM_addPAT()
  668. {
  669.     P_HEAD    header;
  670.     char    *pat;                /* 最適化後のパターン格納領域 */
  671.     short    pal[16];            /* パレットデータ格納領域 */
  672.     short    *patbuf;            /* パターンデータ格納用 */
  673.     short    *tmpbuf;            /* ファイルから読んだ直後のパターン */
  674.     char    fn[13];                /* ファイルネーム */
  675.     int        xlen,ylen;            /* パターンのサイズ */
  676.     int        patx,paty;            /* １６ドット単位のパターンの数 */
  677.     int        dotnum;                /* ドットの数 */
  678.     int        i,j,ret,pt=0;
  679.     
  680.     
  681.     fn[0]=0;
  682.     SPM_fileSelect("ARTemisロード",fn,"");
  683.     if (fn[0]==0)
  684.         return;
  685.     
  686.     YSC_makeFullPath(workfn,drv,path,fn);
  687.     
  688.     if ( (fp=fopen(workfn,"rb"))==NULL)
  689.     {    SPM_errMes("ファイルエラー！"); return;    }
  690.     
  691.     
  692.     fread(&header,sizeof(P_HEAD),1,fp);
  693.     while (!feof(fp))
  694.     {
  695.         /* 読み取り用ポインタ初期化 */
  696.         pt=0;
  697.         /* まずヘッダの解析から */
  698.         /* パターンのサイズを計算 */
  699.         xlen=header.xlen;    ylen=header.ylen;
  700.         patx=(xlen+15)>>4;    paty=(ylen+15)>>4;
  701.         dotnum=patx*paty<<8;
  702.         
  703.         /* パターンデータをメモリに格納 */
  704.         if ( (patbuf=calloc(dotnum*2,1))==NULL)
  705.         { SPM_errMes("メモリが足りません"); return; }
  706.         if ( (tmpbuf=malloc(header.patbufsize))==NULL)
  707.         { SPM_errMes("メモリが足りません"); return; }
  708.         
  709.         fread(tmpbuf,header.patbufsize,1,fp);
  710.         
  711.         /* デバッグ */
  712.         //YGB_putPattern(gwork,(char*)tmpbuf,0,0,239,199);
  713.         
  714.         
  715.         for (i=0;i<ylen;i++)
  716.         {
  717.             /* 補正した時のずれは０で埋める(callocだから不要) */
  718.             for (j=0;j<xlen;j++)
  719.             {    patbuf[(i*patx<<4)+j]=tmpbuf[pt]; pt++;    }
  720.         }
  721.         free(tmpbuf);
  722.         
  723.         /* 構造体の中に入れておく。 */
  724.         if ((pter[PATNUM].header=malloc(sizeof(P_HEAD)))==NULL)
  725.         {    SPM_errMes("メモリが足りません"); return;    }
  726.         _move(&header,pter[PATNUM].header,sizeof(P_HEAD));
  727.         pter[PATNUM].patx=patx;
  728.         pter[PATNUM].paty=paty;
  729.         pter[PATNUM].p32buf=patbuf;
  730.         if ((pter[PATNUM].patbuf=malloc(dotnum/2))==NULL)
  731.         {    SPM_errMes("メモリ不足です"); fclose(fp); return; }
  732.         pter[PATNUM].palnum=-1;
  733.         
  734.         /* デバッグ2 */
  735.         //printf ("No.%03d patx=%02d paty=%02d",PALNUM,patx,paty);
  736.         
  737.         /* 変数をセット */
  738.         PATNUM++;
  739.         SPRNUM+=(patx*paty);
  740.         
  741.         fread(&header,sizeof(P_HEAD),1,fp);
  742.     }
  743.     
  744.     /* スクロールバーを書き換え */
  745.     YGU_resetScrollBar(gwork,itm[29],(PATNUM+5)/6,4);
  746.     YGU_setScrollBarPointer(gwork,itm[29],WINTOP);
  747.     YGB_writeMode(gwork,PSET);
  748.     
  749.     SPM_showWindow(WINTOP*6);
  750.     SPM_printNumber(WINTOP*6);
  751.     
  752.     fclose(fp);
  753.     return;
  754. }
  755.  
  756.  
  757.  
  758.     /* SPP形式でセーブ */
  759. void    SPM_saveSPP()
  760. {
  761.     S_HEAD    hd;
  762.     CHRDAT    chd;
  763.     char    fn[13];                /* ファイルネーム */
  764.     int        dotnum,lx,ly;
  765.     int        i,j,ret,p=0,pn,x,y;
  766.     
  767.     fn[0]=0;
  768.     SPM_fileSelect("SPPセーブ",fn,"SPP");
  769.     if (fn[0]==0)
  770.         return;
  771.     YSC_changeExt(fn,"SPP");
  772.     
  773.     YSC_makeFullPath(workfn,drv,path,fn);
  774.     
  775.     if ( (fp=fopen(workfn,"rb"))!=NULL)
  776.     {
  777.         if (SPM_sure(" @@ 上書きします @@ いいですか？ ",0)==0)
  778.             return;
  779.     }
  780.     fclose(fp);
  781.     if ((fp=fopen(workfn,"wb"))==NULL)
  782.     {    SPM_errMes("ファイルエラー！");    return;    }
  783.     
  784.     SPM_arrangePALnumber();
  785.     SPM_printNumber(WINTOP*6);
  786.     
  787.     hd.patnum=PATNUM;    hd.palnum=PALNUM;    hd.sprnum=SPRNUM;
  788.     
  789.     if (fwrite(&hd,sizeof(S_HEAD),1,fp)!=1)
  790.     {    SPM_errMes("ディスク容量が無いのでは？"); fclose(fp); return; }
  791.     
  792.     for (i=0;i<PATNUM;i++)
  793.     {
  794.         chd.topnum=p;
  795.         p+= (pter[i].patx*pter[i].paty) * ((pter[i].palnum==-1) ? 4 : 1);
  796.         chd.xlen=pter[i].patx;    chd.ylen=pter[i].paty;
  797.         chd.col=(pter[i].palnum==-1) ? 0 : (pter[i].palnum+32768+256);
  798.         if (fwrite(&chd,sizeof(CHRDAT),1,fp)!=1)
  799.         {    SPM_errMes("ディスク容量が無いのでは？"); fclose(fp); return; }
  800.         
  801.     }
  802.     
  803.     for (i=0;i<PALNUM;i++)
  804.     {
  805.         if (fwrite(PAL[i],32,1,fp)!=1)
  806.         {    SPM_errMes("ディスク容量が無いのでは？"); fclose(fp); return; }
  807.     }
  808.     
  809.     for (i=0;i<PATNUM;i++)
  810.     {
  811.         /* 32K */
  812.         if (pter[i].palnum==-1)
  813.         {
  814.             lx=pter[i].patx;    ly=pter[i].paty;
  815.             for (y=0;y<ly;y++)
  816.             {
  817.                 for (x=0;x<lx;x++)
  818.                 {
  819.                     for (j=0;j<16;j++)
  820.                     {
  821.                         _move(&pter[i].p32buf[(y*lx<<8)+(x<<4)+(j*lx<<4)],
  822.                                 &saveBuf[j<<5],32);
  823.                     }
  824.                     fwrite(saveBuf,512,1,fp);
  825.                 }
  826.             }
  827.         }
  828.         else    /* 16 */
  829.         {
  830.             lx=pter[i].patx;    ly=pter[i].paty;
  831.             for (y=0;y<ly;y++)
  832.             {
  833.                 for (x=0;x<lx;x++)
  834.                 {
  835.                     for (j=0;j<16;j++)
  836.                     {
  837.                         _move(&pter[i].patbuf[(y*lx<<7)+(x<<3)+(j*lx<<3)],
  838.                                 &saveBuf[j<<3],8);
  839.                     }
  840.                     if (fwrite(saveBuf,128,1,fp)!=1)
  841.                     {
  842.                         SPM_errMes("ディスク容量が無いのでは？");
  843.                         fclose(fp);
  844.                         return;
  845.                     }
  846.                 }
  847.             }
  848.         }
  849.     }
  850.     fclose(fp);
  851.     return;
  852. }
  853.  
  854.  
  855.     /* SPP新規読み込み */
  856. void    SPM_readNewSPP()
  857. {
  858.     S_HEAD    hd;
  859.     CHRDAT    chd;
  860.     char    fn[13];                /* ファイルネーム */
  861.     char    *tmpbuf;
  862.     int        dotnum,lx,ly;
  863.     int        i,j,ret,p=0,pn,x,y;
  864.     
  865.     fn[0]=0;
  866.     SPM_fileSelect("SPP新規読み込み",fn,"SPP");
  867.     if (fn[0]==0)
  868.         return;
  869.     YSC_changeExt(fn,"SPP");
  870.     
  871.     YSC_makeFullPath(workfn,drv,path,fn);
  872.     
  873.     if ((fp=fopen(workfn,"rb"))==NULL)
  874.     {    SPM_errMes("ファイルエラー！");    return;    }
  875.     
  876.     
  877.     /* いままで保持していたデータ領域の開放 */
  878.     for (i=0;i<PATNUM;i++)
  879.     {
  880.         free(pter[i].patbuf);
  881.         free(pter[i].p32buf);
  882.         if (pter[i].header!=NULL)
  883.         free(pter[i].header);
  884.     }
  885.     
  886.     
  887.     fread(&hd,6,1,fp);
  888.     
  889.     PATNUM=hd.patnum;    PALNUM=hd.palnum;    SPRNUM=hd.sprnum;    stkpal=-1;
  890.     _fill_char(PAL_USE,2048,0);
  891.     
  892.     for (i=0;i<PATNUM;i++)
  893.     {
  894.         fread(&chd,8,1,fp);
  895.         if ((pter[i].p32buf=(short*)malloc((chd.xlen*chd.ylen)<<9))==NULL)
  896.         {    SPM_errMes("メモリ不足です");fclose(fp);return; }
  897.         
  898.         if ((pter[i].patbuf=(char*)malloc((chd.xlen*chd.ylen)<<7))==NULL)
  899.         {    SPM_errMes("メモリ不足です");fclose(fp);return; }
  900.         pter[i].header=NULL;
  901.         pter[i].patx=chd.xlen;    pter[i].paty=chd.ylen;
  902.         pter[i].palnum=chd.col;
  903.         if (pter[i].palnum==0)
  904.             pter[i].palnum--;
  905.         else
  906.             pter[i].palnum=(pter[i].palnum & 32767)-256;
  907.     }
  908.     
  909.     for (i=0;i<PALNUM;i++)
  910.         fread(PAL[i],32,1,fp);
  911.     
  912.     if ((tmpbuf=(char*)malloc(512))==NULL)
  913.     {    SPM_errMes("メモリ不足です");fclose(fp);return; }
  914.     
  915.     for (i=0;i<PATNUM;i++)
  916.     {
  917.         lx=pter[i].patx;    ly=pter[i].paty;
  918.         /* 32K */
  919.         if (pter[i].palnum==-1)
  920.         {
  921.             for (y=0;y<ly;y++)
  922.             {
  923.                 for(x=0;x<lx;x++)
  924.                 {
  925.                     fread(tmpbuf,1,512,fp);
  926.                     for (j=0;j<16;j++)
  927.                     {
  928.                         _move(&(tmpbuf[j<<5]),
  929.                             &(pter[i].p32buf[(y*lx<<8)+(x<<4)+(j*lx<<4)]),32);
  930.                     }
  931.                 }
  932.             }
  933.         }
  934.         else    /* 16 */
  935.         {
  936.             for (y=0;y<ly;y++)
  937.             {
  938.                 for(x=0;x<lx;x++)
  939.                 {
  940.                     fread(tmpbuf,128,1,fp);
  941.                     for (j=0;j<16;j++)
  942.                     {
  943.                         _move(&tmpbuf[j<<3],
  944.                             (&pter[i].patbuf[(y*lx<<7)+(x<<3)+(j*lx<<3)]),8);
  945.                     }
  946.                 }
  947.             }
  948.             SPM_expand(i,pter[i].patx*16,pter[i].paty*16,
  949.                     PAL[pter[i].palnum],pter[i].p32buf);
  950.             PAL_USE[pter[i].palnum]++;
  951.         }
  952.     }
  953.     fclose(fp);
  954.     YGU_resetScrollBar(gwork,itm[29],(PATNUM+5)/6,4);
  955.     YGB_writeMode(gwork,PSET);
  956.     WINTOP=0;
  957.     SPM_showWindow(0);
  958.     SPM_printNumber(0);
  959.     free(tmpbuf);
  960.     return;
  961. }
  962.  
  963.  
  964.  
  965. /* SPM追加 */
  966. void    SPM_addSPP()
  967. {
  968.     S_HEAD    hd;
  969.     CHRDAT    chd;
  970.     char    fn[13];                /* ファイルネーム */
  971.     char    *tmpbuf;
  972.     int        dotnum,lx,ly;
  973.     int        i,j,ret,p=0,pn,x,y;
  974.     
  975.     fn[0]=0;
  976.     SPM_fileSelect("SPP新規読み込み",fn,"SPP");
  977.     if (fn[0]==0)
  978.         return;
  979.     YSC_changeExt(fn,"SPP");
  980.     
  981.     YSC_makeFullPath(workfn,drv,path,fn);
  982.     
  983.     if ((fp=fopen(workfn,"rb"))==NULL)
  984.     {    SPM_errMes("ファイルエラー！");    return;    }
  985.     
  986.     /* 最初にバッファを確保 */
  987.     if ((tmpbuf=(char*)malloc(512))==NULL)
  988.     {    SPM_errMes("メモリ不足です");fclose(fp);return; }
  989.     
  990.     fread(&hd,6,1,fp);
  991.     
  992.     SPM_arrangePALnumber();
  993.     
  994.     for (i=PATNUM;i<PALNUM+hd.patnum;i++)
  995.     {
  996.         fread(&chd,8,1,fp);
  997.         if ((pter[i].p32buf=(short*)malloc((chd.xlen*chd.ylen)<<9))==NULL)
  998.         {    SPM_errMes("メモリ不足です");fclose(fp);return; }
  999.         
  1000.         if ((pter[i].patbuf=(char*)malloc((chd.xlen*chd.ylen)<<7))==NULL)
  1001.         {    SPM_errMes("メモリ不足です");fclose(fp);return; }
  1002.         pter[i].header=NULL;
  1003.         pter[i].patx=chd.xlen;    pter[i].paty=chd.ylen;
  1004.         pter[i].palnum=chd.col;
  1005.         if (pter[i].palnum==0)
  1006.             pter[i].palnum--;
  1007.         else
  1008.             pter[i].palnum=(pter[i].palnum & 32767)-256+PALNUM;
  1009.     }
  1010.     
  1011.     for (i=0;i<hd.palnum;i++)
  1012.         fread(PAL[i+PALNUM],32,1,fp);
  1013.     
  1014.     for (i=PATNUM;i<PATNUM+hd.patnum;i++)
  1015.     {
  1016.         lx=pter[i].patx;    ly=pter[i].paty;
  1017.         /* 32K */
  1018.         if (pter[i].palnum==-1)
  1019.         {
  1020.             for (y=0;y<ly;y++)
  1021.             {
  1022.                 for(x=0;x<lx;x++)
  1023.                 {
  1024.                     fread(tmpbuf,512,1,fp);
  1025.                     for (j=0;j<16;j++)
  1026.                     {
  1027.                         _move( (&tmpbuf[j<<5]),
  1028.                             (&pter[i].p32buf[(y*lx<<8)+(x<<4)+(j*lx<<4)]),32);
  1029.                     }
  1030.                 }
  1031.             }
  1032.         }
  1033.         else    /* 16 */
  1034.         {
  1035.             for (y=0;y<ly;y++)
  1036.             {
  1037.                 for(x=0;x<lx;x++)
  1038.                 {
  1039.                     fread(tmpbuf,128,1,fp);
  1040.                     for (j=0;j<16;j++)
  1041.                     {
  1042.                         _move(&tmpbuf[j<<3],
  1043.                             (&pter[i].patbuf[(y*lx<<7)+(x<<3)+(j*lx<<3)]),8);
  1044.                     }
  1045.                 }
  1046.             }
  1047.             SPM_expand(i,pter[i].patx*16,pter[i].paty*16,
  1048.                     PAL[pter[i].palnum],pter[i].p32buf);
  1049.             PAL_USE[pter[i].palnum]++;
  1050.         }
  1051.     }
  1052.     
  1053.     PATNUM+=hd.patnum;    PALNUM+=hd.palnum;    SPRNUM+=hd.sprnum;
  1054.     
  1055.     fclose(fp);
  1056.     YGU_resetScrollBar(gwork,itm[29],(PATNUM+5)/6,4);
  1057.     YGU_setScrollBarPointer(gwork,itm[29],WINTOP);
  1058.     YGB_writeMode(gwork,PSET);
  1059.     SPM_showWindow(WINTOP*6);
  1060.     SPM_printNumber(WINTOP*6);
  1061.     free(tmpbuf);
  1062.     return;
  1063. }
  1064.  
  1065.  
  1066.  
  1067.     /* ARTemis形式でセーブ */
  1068. void    SPM_savePAT()
  1069. {
  1070.     P_HEAD    header;
  1071.     char    fn[13];                /* ファイルネーム */
  1072.     char    name[41];            /* パターンの名前を一時的に格納するバッファ */
  1073.     int        dotnum;
  1074.     int        i,j,ret,pt=0;
  1075.     
  1076.     
  1077.     fn[0]=0;
  1078.     SPM_fileSelect("ARTemisセーブ",fn,"");
  1079.     if (fn[0]==0)
  1080.         return;
  1081.     
  1082.     YSC_makeFullPath(workfn,drv,path,fn);
  1083.     
  1084.     if ( (fp=fopen(workfn,"rb"))!=NULL)
  1085.     {
  1086.         if (SPM_sure(" @@ 上書きします @@ いいですか？ ",0)==0)
  1087.             return;
  1088.     }
  1089.     fclose(fp);
  1090.     if ((fp=fopen(workfn,"wb"))==NULL)
  1091.     {    SPM_errMes("ファイルエラー！");    return;    }
  1092.     
  1093.     
  1094.     
  1095.     for (i=0;i<PATNUM;i++)
  1096.     {
  1097.         dotnum=pter[i].patx*pter[i].paty<<8;
  1098.         if (pter[i].header==NULL)
  1099.         {
  1100.             sprintf(name,"SPP-%d",i);
  1101.             strcpy(header.name,name);
  1102.             sprintf(name,"%d",i);
  1103.             strcpy(header.subname,name);
  1104.             header.xlen=pter[i].patx<<4;
  1105.             header.ylen=pter[i].paty<<4;
  1106.             header.bufx=(i%13)<<4;
  1107.             header.bufy=(i/13)<<4;
  1108.             header.patbufsize=dotnum<<1;
  1109.             header.res1=0;    header.res2=1; header.res3=1; header.res4[0]=0;
  1110.             header.selected=0; header.nodisp=0;
  1111.         }
  1112.         else
  1113.         {
  1114.             _move(pter[i].header,&header,sizeof(P_HEAD));
  1115.             header.xlen=pter[i].patx<<4;
  1116.             header.ylen=pter[i].paty<<4;
  1117.             header.patbufsize=dotnum<<1;
  1118.         }
  1119.         if (fwrite(&header,sizeof(P_HEAD),1,fp)!=1)
  1120.         {SPM_errMes("ディスク容量が不足してませんか？");fclose(fp);return;    }
  1121.         if (pter[i].palnum!=-1)
  1122.         {
  1123.             if (SPM_plus32K(i)!=0)
  1124.                 return;
  1125.         }
  1126.         if (fwrite(pter[i].p32buf,2,dotnum,fp)!=dotnum)
  1127.         {SPM_errMes("ディスク容量が不足してませんか？");fclose(fp);return;    }
  1128.     }
  1129.     fclose(fp);
  1130.     return;
  1131. }
  1132.  
  1133.  
  1134.  
  1135.  
  1136.  
  1137.  
  1138.  
  1139. /* 最適化メニュー */
  1140.     /* 指定範囲を１６色に */
  1141. void    SPM_be16(int st,int en)
  1142. {
  1143.     int        i,j,ret,flag=0;
  1144.     short    *patbuf;            /* パターンデータ格納用 */
  1145.     char    *pat;
  1146.     int        dotnum;                /* ドットの数 */
  1147.     
  1148.     
  1149.     for (i=st;i<en+1;i++)
  1150.     {
  1151.         dotnum=pter[i].patx*pter[i].paty*256;
  1152.         if (pter[i].palnum!=-1)
  1153.             continue;
  1154.         
  1155.         for (j=0;j<1024;j++)
  1156.         {
  1157.             if (PAL_USE[j]==0)
  1158.             {
  1159.                 PAL_USE[j]++; flag=1;
  1160.                 pter[i].palnum=j;    PALNUM++;
  1161.                 break;
  1162.             }
  1163.         }
  1164.         
  1165.         if (flag==0)
  1166.         {    SPM_errMes("パレットの定義数が多すぎます");return;}
  1167.         
  1168.         patbuf=pter[i].p32buf;
  1169.         /* １６色に最適化する */
  1170.         ret=SOP_selPal(PAL[pter[i].palnum],patbuf,dotnum,OP_LEVEL*OP_LEVEL);
  1171.         if (ret!=0)
  1172.             { SPM_errMes("最適化中にメモリ不足が生じたようです。"); return; }
  1173.         ret=SOP_optimize(pter[i].patbuf,PAL[pter[i].palnum],patbuf,dotnum);
  1174.         if (ret!=0)
  1175.             { SPM_errMes("最適化中にメモリ不足が生じたようです。"); return; }
  1176.         
  1177.     }
  1178.     
  1179.     SPM_showWindow(WINTOP*6);
  1180.     SPM_printNumber(WINTOP*6);
  1181.     
  1182.     return;
  1183. }
  1184.  
  1185.  
  1186.  
  1187.     /* 全部１６色にする */
  1188. void    SPM_all16()
  1189. {
  1190.     SPM_be16(0,PATNUM-1);
  1191.     return;
  1192. }
  1193.  
  1194.  
  1195.  
  1196.  
  1197.     /* 範囲指定付き１６色最適化 */
  1198. void    SPM_limit16()
  1199. {
  1200.     int        st,en;
  1201.     
  1202.     st=SPM_getScope();
  1203.     en=st & 65535;
  1204.     st=st>>16;
  1205.     
  1206.     SPM_be16(st,en);
  1207.     return;
  1208. }
  1209.  
  1210.  
  1211.  
  1212.  
  1213.     /* 退避中のパレットによる最適化 */
  1214. void    SPM_pushed()
  1215. {
  1216.     int        i,j,ret,st,en;
  1217.     short    *patbuf;            /* パターンデータ格納用 */
  1218.     char    *pat;
  1219.     int        dotnum;                /* ドットの数 */
  1220.     
  1221.     if (stkpal==-1)
  1222.     {    SPM_errMes("パレットが退避先に有りません");    return;    }
  1223.     
  1224.     
  1225.     st=SPM_getScope();
  1226.     en=st & 65535;
  1227.     st=st>>16;
  1228.     
  1229.     for (i=st;i<en+1;i++)
  1230.     {
  1231.         dotnum=pter[i].patx*pter[i].paty*256;
  1232.         if (pter[i].palnum!=-1)
  1233.             continue;
  1234.         if (pter[i].palnum==stkpal)
  1235.             continue;
  1236.         
  1237.         PAL_USE[stkpal]++;
  1238.         pter[i].palnum=stkpal;
  1239.         patbuf=pter[i].p32buf;
  1240.         /* １６色に最適化する */
  1241.         ret=SOP_optimize(pter[i].patbuf,PAL[stkpal],patbuf,dotnum);
  1242.         if (ret!=0)
  1243.             { SPM_errMes("最適化中にメモリ不足が生じたようです。"); return; }
  1244.         
  1245.     }
  1246.     
  1247.     SPM_showWindow(WINTOP*6);
  1248.     SPM_printNumber(WINTOP*6);
  1249.     
  1250.     return;
  1251. }
  1252.  
  1253.  
  1254.  
  1255.  
  1256.     /* ３２Ｋ色化 */
  1257. void    SPM_be32K(int st,int en)
  1258. {
  1259.     int        i;
  1260.     
  1261.     for (i=st;i<en+1;i++)
  1262.     {
  1263.         if (pter[i].p32buf==NULL)
  1264.             continue;
  1265.         if (pter[i].palnum==-1)
  1266.             continue;
  1267.         
  1268.         if ((--PAL_USE[pter[i].palnum]) == 0)
  1269.             PALNUM--;
  1270.         pter[i].palnum=-1;
  1271.     }
  1272.     
  1273.     SPM_showWindow(WINTOP*6);
  1274.     SPM_printNumber(WINTOP*6);
  1275.     
  1276.     return;
  1277. }
  1278.  
  1279.  
  1280.     /* 全部３２Ｋ色 */
  1281. void    SPM_all32K()
  1282. {
  1283.     SPM_be32K(0,PATNUM-1);
  1284.     return;
  1285. }
  1286.  
  1287.  
  1288.     /* 範囲指定付き３２Ｋ色化 */
  1289. void    SPM_limit32K()
  1290. {
  1291.     int        st,en;
  1292.     
  1293.     st=SPM_getScope();
  1294.     en=st & 65535;
  1295.     st=st>>16;
  1296.     
  1297.     SPM_be32K(st,en);
  1298.     return;
  1299. }
  1300.  
  1301.  
  1302.  
  1303. /* １６色以下を全部最適化 */
  1304. void    SPM_under16()
  1305. {
  1306.     
  1307.     short    *patbuf;
  1308.     char    *pat;
  1309.     int        dotnum,flag;
  1310.     int        colnum=0;
  1311.     int        i,j,ref,ret,min,d,min_i,min_j;
  1312.     short    *buf;
  1313.     
  1314.     for (i=0;i<PATNUM;i++)
  1315.     {
  1316.         /* 32K以外お断り */
  1317.         if (pter[i].palnum!=-1)
  1318.             continue;
  1319.         
  1320.         flag=0;
  1321.         colnum=0;
  1322.         patbuf=pter[i].p32buf;
  1323.         dotnum=pter[i].patx*pter[i].paty*256;
  1324.         /* バッファを確保 */
  1325.         if ( (buf=malloc(dotnum*2))==NULL)
  1326.         {    SPM_errMes("メモリが足りません"); return; }
  1327.         
  1328.         /* バッファにコピー */
  1329.         _move(patbuf,buf,dotnum*2);
  1330.         
  1331.         /* 色番号順にソート */
  1332.         SOP_qsort(buf,0,dotnum-1);
  1333.         
  1334.         /* 色数のカウント*/
  1335.         ref=buf[0]; colnum++;
  1336.         for (j=1;j<dotnum;j++)
  1337.         {
  1338.             if (ref!=buf[j])
  1339.             { ref=buf[j];buf[colnum]=ref; colnum++; }
  1340.         }
  1341.         free(buf);
  1342.         
  1343.         /* 16色以下なら最適化 */
  1344.         if (colnum>16)
  1345.             continue;
  1346.         
  1347.         /* あいてるパレットを探す */
  1348.         for (j=0;j<1024;j++)
  1349.         {
  1350.             if (PAL_USE[j]==0)
  1351.             {
  1352.                 PAL_USE[j]++; flag=1;
  1353.                 pter[i].palnum=j;    PALNUM++;
  1354.                 break;
  1355.             }
  1356.         }
  1357.         
  1358.         if (flag==0)
  1359.         {    SPM_errMes("パレットの定義数が多すぎます");return;}
  1360.         
  1361.         /* １６色に最適化する */
  1362.         ret=SOP_selPal(PAL[pter[i].palnum],patbuf,dotnum,OP_LEVEL*OP_LEVEL);
  1363.         if (ret!=0)
  1364.             { SPM_errMes("最適化中にメモリ不足が生じたようです。"); return; }
  1365.         ret=SOP_optimize(pter[i].patbuf,PAL[pter[i].palnum],patbuf,dotnum);
  1366.         if (ret!=0)
  1367.             { SPM_errMes("最適化中にメモリ不足が生じたようです。"); return; }
  1368.         
  1369.     }
  1370.     
  1371.     SPM_showWindow(WINTOP*6);
  1372.     SPM_printNumber(WINTOP*6);
  1373.     
  1374.     return;
  1375. }
  1376.  
  1377.  
  1378.  
  1379.  
  1380. /* ３２Ｋ色データをメモリに持たない１６色パターンに３２Ｋデータを与える */
  1381. int        SPM_plus32K(int num)
  1382. {
  1383.     SPM_expand(num,pter[num].patx*16,pter[num].paty*16,
  1384.                                 PAL[pter[num].palnum],pter[num].p32buf);
  1385.     return(0);
  1386. }
  1387.  
  1388.  
  1389.  
  1390.  
  1391. /* パレット番号の整理 */
  1392. int        SPM_arrangePALnumber()
  1393. {
  1394.     int        i,j,p,d;
  1395.     
  1396.     
  1397.     if (stkpal!=-1)
  1398.     {
  1399.         SPM_sure(" @@ @@ パレット退避用領域をクリアします ",2);
  1400.         
  1401.         if ( (--PAL_USE[stkpal])==0 )
  1402.             PALNUM--;
  1403.         stkpal=-1;
  1404.     }
  1405.     
  1406.     for (i=0;i<1024;i++)
  1407.     {
  1408.         d=0;
  1409.         if (PAL_USE[i]==0)
  1410.         {
  1411.             pal_lab:;
  1412.             d++;
  1413.             if (i+d>1023)
  1414.                 break;
  1415.             if (PAL_USE[i+d]==0)
  1416.                 goto pal_lab;
  1417.             for (j=i;j<1024-d;j++)
  1418.             {
  1419.                 PAL_USE[j]=PAL_USE[j+d];
  1420.                 _move(PAL[j+d],PAL[j],32);
  1421.             }
  1422.             for (j=1024-d;j<1024;j++)
  1423.             {
  1424.                 PAL_USE[j]=0;
  1425.                 _fill_char(PAL[j],32,0);
  1426.             }
  1427.             for (j=0;j<PATNUM;j++)
  1428.             {
  1429.                 if (pter[j].palnum>=i+d)
  1430.                     pter[j].palnum-=d;
  1431.             }
  1432.         }
  1433.     }
  1434.     
  1435.     return(0);
  1436. }
  1437.  
  1438.  
  1439.  
  1440.  
  1441. /* フリーメモリの表示 */
  1442. void    SPM_freeMem()
  1443. {
  1444.     int        k=1,m=1;
  1445.     char    *dmy,*dmy2;
  1446.     char    str[100];
  1447.     
  1448.     /* まずは、メガバイト単位から */
  1449.     
  1450.     if ((dmy=malloc(1024*1024))==NULL)
  1451.     {    m=0;    goto KB;    }
  1452.     while(realloc(dmy,m*1024*1024)!=NULL)
  1453.         m++;
  1454.     
  1455.     /* 次にキロバイト単位 */
  1456.     KB:;
  1457.     if ((dmy2=(char*)malloc(1024))==NULL)
  1458.     {    k=0;    goto ED;    }
  1459.     while(realloc(dmy2,k*1024)!=NULL)
  1460.         k++;
  1461.     
  1462.     ED:;
  1463.     free(dmy);
  1464.     free(dmy2);
  1465.     
  1466.     sprintf(str," @@ @@FREE MEMORY...%dKbytes",(m-1)*1024+k-1);
  1467.     SPM_sure(str,2);
  1468.     return;
  1469. }
  1470.  
  1471.  
  1472.  
  1473.  
  1474. /* 範囲入力(始まり*65536+終わりを返す)、PATNUM=0で9999 */
  1475. int        SPM_getScope()
  1476. {
  1477.     ITEM    *itms[26],*act;
  1478.     int        i,j,x,y;
  1479.     int        flag=0;    /* ループ抜け出し用 */
  1480.     int        wb;        /* WINTOP退避用 */
  1481.     int        ret=0;
  1482.     
  1483.     
  1484.     if (PATNUM==0)
  1485.         return(9999);
  1486.     
  1487.     SPM_sure("@@ @@始まるパターンは？",2);
  1488.     
  1489.     
  1490.     /* ダミー */
  1491.     itms[0]=YGU_addButton(NULL,511,511,1,1);
  1492.     
  1493.     /* 各パターン表示ウィンドウ itms 1-24 */
  1494.     for (j=0;j<4;j++)
  1495.     {
  1496.         for (i=0;i<6;i++)
  1497.         {
  1498.             x = i * sprWinStep_x + sprWin_x;
  1499.             y = j * sprWinStep_y + sprWin_y;
  1500.             YGU_addButton(itms[0],x+6,y+6,64,64);
  1501.         }
  1502.     }
  1503.     
  1504.     
  1505.     /* スクロールバー (itms 25)*/
  1506.     YGU_addLongitudinalbar(gwork,itms[0],0,20,12,458,(PATNUM+5)/6,4);
  1507.     YGU_setScrollBarPointer(gwork,itms[25],WINTOP);
  1508.     YGB_writeMode(gwork,PSET);
  1509.     wb=WINTOP;
  1510.     
  1511.     for (i=0;i<25;i++)
  1512.         itms[i+1]=YGU_nextItem(itms[i]);
  1513.     
  1514.     
  1515.     while(flag<2)
  1516.     {
  1517.         act=YGU_allItemsAction(gwork,itms[0]);
  1518.         i=YGU_itemSerialNumber(itms[0],act);
  1519.         switch(i)
  1520.         {
  1521.             default:    break;
  1522.             case 2..25:
  1523.             {
  1524.                 if (WINTOP*6+i-2 >= PATNUM)
  1525.                     break;
  1526.                 ret+=WINTOP*6+i-2; flag++;
  1527.                 if (flag==1)
  1528.                 {
  1529.                     ret=ret<<16;
  1530.                     SPM_sure(" @@ @@では、終わるパターンは？",2);
  1531.                 }
  1532.                 break;
  1533.             }
  1534.             case 26:
  1535.             {
  1536.                 j=YGU_getScrollBarPointer(itms[25]);
  1537.                 if (_abs((j-WINTOP))<=3)
  1538.                     SPM_scrollShowWindow(j-WINTOP);
  1539.                 else
  1540.                 {
  1541.                     WINTOP=j;
  1542.                     SPM_showWindow(WINTOP*6);
  1543.                 }
  1544.             }
  1545.         }
  1546.     }
  1547.     
  1548.     YGU_deleteAll(itms[0]);
  1549.     WINTOP=wb;
  1550.     YGU_setScrollBarPointer(gwork,itm[29],WINTOP);
  1551.     SPM_showWindow(WINTOP*6);
  1552.     return(ret);
  1553. }
  1554.  
  1555.  
  1556.  
  1557.  
  1558. /* 一つのパターンを指定させる */
  1559. int        SPM_getOne()
  1560. {
  1561.     ITEM    *itms[26],*act;
  1562.     int        i,j,x,y;
  1563.     int        flag=0;    /* ループ抜け出し用 */
  1564.     int        wb;        /* WINTOP退避用 */
  1565.     int        ret;
  1566.     
  1567.     
  1568.     if (PATNUM==0)
  1569.         return(9999);
  1570.     
  1571.     SPM_sure("@@ @@どのパターンですか？",2);
  1572.     
  1573.     
  1574.     /* ダミー */
  1575.     itms[0]=YGU_addButton(NULL,511,511,1,1);
  1576.     
  1577.     /* 各パターン表示ウィンドウ itms 1-24 */
  1578.     for (j=0;j<4;j++)
  1579.     {
  1580.         for (i=0;i<6;i++)
  1581.         {
  1582.             x = i * sprWinStep_x + sprWin_x;
  1583.             y = j * sprWinStep_y + sprWin_y;
  1584.             YGU_addButton(itms[0],x+6,y+6,64,64);
  1585.         }
  1586.     }
  1587.     
  1588.     
  1589.     /* スクロールバー (itms 25)*/
  1590.     YGU_addLongitudinalbar(gwork,itms[0],0,20,12,458,(PATNUM+5)/6,4);
  1591.     YGU_setScrollBarPointer(gwork,itms[25],WINTOP);
  1592.     YGB_writeMode(gwork,PSET);
  1593.     wb=WINTOP;
  1594.     
  1595.     for (i=0;i<25;i++)
  1596.         itms[i+1]=YGU_nextItem(itms[i]);
  1597.     
  1598.     
  1599.     while(flag==0)
  1600.     {
  1601.         act=YGU_allItemsAction(gwork,itms[0]);
  1602.         i=YGU_itemSerialNumber(itms[0],act);
  1603.         switch(i)
  1604.         {
  1605.             default:    break;
  1606.             case 2..25:
  1607.             {
  1608.                 ret=WINTOP*6+i-2; flag++;
  1609.                 break;
  1610.             }
  1611.             case 26:
  1612.             {
  1613.                 j=YGU_getScrollBarPointer(itms[25]);
  1614.                 if (_abs((j-WINTOP))<=3)
  1615.                     SPM_scrollShowWindow(j-WINTOP);
  1616.                 else
  1617.                 {
  1618.                     WINTOP=j;
  1619.                     SPM_showWindow(WINTOP*6);
  1620.                 }
  1621.             }
  1622.         }
  1623.     }
  1624.     
  1625.     YGU_deleteAll(itms[0]);
  1626.     WINTOP=wb;
  1627.     YGU_setScrollBarPointer(gwork,itm[29],WINTOP);
  1628.     SPM_showWindow(WINTOP*6);
  1629.     return(ret);
  1630. }
  1631.  
  1632.  
  1633.  
  1634.  
  1635.  
  1636.  
  1637.  
  1638.  
  1639. /* ウェイト */
  1640. void    SPM_wait(int count)
  1641. {
  1642.     int        a,b;
  1643.     b=MOS_getTime();
  1644.     while(1)
  1645.     {
  1646.         a=MOS_getTime();
  1647.         if ( a-b > count )
  1648.             break;
  1649.     }
  1650.     return;
  1651. }
  1652.  
  1653.  
  1654. /* リドロー */
  1655. void    SPM_redraw()
  1656. {
  1657.     int        x,y,i,j,r;
  1658.     char    para[64];
  1659.     
  1660.     MOS_disp(0);
  1661.     YGB_writeMode(gwork,PSET);
  1662.     
  1663.     YGB_color(gwork,0);
  1664.     
  1665.     /* どれにしようかな？(^^;) */
  1666.     dice:;
  1667.     r=rand()&3;
  1668.     
  1669.     switch (r)
  1670.     {
  1671.         case 0:
  1672.             /* HEwinの反対っぽい消去 */
  1673.             for (i=0;i<16;i++)
  1674.             {
  1675.                 for (j=0;j<32;j++)
  1676.                 {
  1677.                     YGB_line(gwork,(j<<4)+i,0,(j<<4)+i,479);
  1678.                     if (j<30)
  1679.                         YGB_line(gwork,0,(j<<4)+i,511,(j<<4)+i);
  1680.                 }
  1681.             }
  1682.             break;
  1683.         
  1684.         case 1:
  1685.             /* ブラインド？ */
  1686.             for (i=15;i>=0;i--)
  1687.             {
  1688.                 for (j=0;j<30;j++)
  1689.                     YGB_line(gwork,0,(j<<4)+i,511,(j<<4)+i);
  1690.                         SPM_wait(1);
  1691.             }
  1692.             break;
  1693.         
  1694.         case 2:
  1695.             /* 上スクロール */
  1696.             for (i=1;i<40;i++)
  1697.             {
  1698.                 EGB_displayStart(gwork,1,0,i*12);
  1699.                 YGB_boxFul(gwork,0,(i-1)*12,511,(i-1)*12+11);
  1700.             }
  1701.             EGB_displayStart(gwork,1,0,0);
  1702.             break;
  1703.         
  1704.         case 3:
  1705.             /* ソーサリアン？ */
  1706.             EGB_maskBit(gwork,0x7c007c00);
  1707.             YGB_boxFul(gwork,0,0,511,479);
  1708.             SPM_wait(10);
  1709.             
  1710.             EGB_maskBit(gwork,0x001f001f);
  1711.             YGB_boxFul(gwork,0,0,511,479);
  1712.             SPM_wait(10);
  1713.             
  1714.             EGB_maskBit(gwork,0x03e003e0);
  1715.             YGB_boxFul(gwork,0,0,511,479);
  1716.             SPM_wait(10);
  1717.             
  1718.             EGB_maskBit(gwork,0xffffffff);
  1719.             break;
  1720.     }
  1721.     
  1722.     /* 背景色 */
  1723.     YGB_color(gwork,C_BACK);
  1724.     YGB_boxFul(gwork,0,0,511,479);
  1725.     
  1726.     /* 画面上方の溝(?) */
  1727.     YGB_color(gwork,C_BACK);
  1728.     YGB_boxFul(gwork,259,-2,494,18);
  1729.     
  1730.     /* ＥＸＩＴボタン (itm[0])*/
  1731.     SGB_gradProButton(gwork,493,0,511,18,_C(24,24,24),_C(8,8,8),0);
  1732.     
  1733.     
  1734.     /* タイトル (itm[1])*/
  1735.     SGB_gradProButton(gwork,0,0,112,18,_C(12,12,12),_C(0,0,0),0);
  1736.     YGB_color(gwork,_C(25,25,25));
  1737.     YGB_fontSize(gwork,6,12);
  1738.     YGB_print(gwork,15,14,"ＳＰＰ Ver1.00");
  1739.     YGB_color(gwork,_C(27,27,27));
  1740.     YGB_print(gwork,16,14,"ＳＰＰ Ver1.00");
  1741.     
  1742.     /* ファイルメニュー (itm[2])*/
  1743.     SGB_proButton(gwork,113,0,192,18, _C(0,0,0));
  1744.     YGB_color(gwork,_C(27,27,27));
  1745.     YGB_print(gwork,128,14,"ファイル");
  1746.     YGB_color(gwork,_C(12,12,12));
  1747.     YGB_fontSize(gwork,3,6);
  1748.     YGB_print(gwork,179,13,"▼");
  1749.     
  1750.     /* 最適化メニュー (itm[3])*/
  1751.     SGB_proButton(gwork,193,0,260,18, _C(0,0,0));
  1752.     YGB_color(gwork,_C(27,27,27));
  1753.     YGB_fontSize(gwork,6,12);
  1754.     YGB_print(gwork,208,14,"最適化");
  1755.     YGB_color(gwork,_C(12,12,12));
  1756.     YGB_fontSize(gwork,3,6);
  1757.     YGB_print(gwork,247,13,"▼");
  1758.     
  1759.     
  1760.     /* 現在のパターン番号等表示 */
  1761.     YGB_fontSize(gwork,6,12);
  1762.     SGB_holButton(gwork,print_x,print_y,print_x+191,print_y+15,_C(0,0,0));
  1763.     YGB_color(gwork,_C(27,27,27));
  1764.     YGB_print(gwork,print_x+2,print_y+13,"now:");
  1765.     SPM_printNumber(0);
  1766.     
  1767.     
  1768.     /* 各キャラデータの表示ウィンドウ(itm[4]-itm[27]) */
  1769.     x = sprWin_x;
  1770.     y = sprWin_y;
  1771.     /* パターン表示 */
  1772.     SGB_proButton(gwork,x  ,y,  x+75,y+75, _C(22,22,22));
  1773.     SGB_holButton(gwork,x+6,y+6,x+69,y+69, _C(0,0,0));
  1774.     /* パレットの表示 */
  1775.     SGB_holButton(gwork,x   ,y+78,x+74,y+98, _C(0,0,0));
  1776.     
  1777.     YGB_getPattern(gwork,frameBuf,x,y,x+75,y+98);
  1778.     
  1779.     /* コピーする(一回余分があるけどまあいいね(^^;)) */
  1780.     for (j=0;j<4;j++)
  1781.     {
  1782.         for (i=0;i<6;i++)
  1783.         {
  1784.             x = i * sprWinStep_x + sprWin_x;
  1785.             y = j * sprWinStep_y + sprWin_y;
  1786.             YGB_putPattern(gwork,frameBuf,x,y,x+75,y+98);
  1787.             
  1788.         }
  1789.     }
  1790.     
  1791.     YGU_setScrollBarPointer(gwork,itm[29],WINTOP);
  1792.     SPM_showWindow(WINTOP*6);
  1793.     SPM_printNumber(WINTOP*6);
  1794.     MOS_rdpos(&i,&x,&y);
  1795.     MOS_setpos(x,y);
  1796.     MOS_disp(1);
  1797.     
  1798.     return;
  1799. }
  1800.  
  1801.  
  1802.  
  1803.  
  1804.  
  1805.  
  1806.  
  1807. /* 透過色の指定 */
  1808. void    SPM_setThru()
  1809. {
  1810.     
  1811.     return;
  1812. }
  1813.  
  1814.  
  1815.